import os
import time
# from pywinauto import Application
# from pywinauto.findwindows import find_window  # 确保导入find_window函数
import shutil
import zipfile
import tarfile
import argparse
from pathlib import Path
from datetime import datetime
import win32api, win32con

def is_pac_file(file_path):
    """检查文件是否为pac格式(通过扩展名)"""
    return file_path.lower().endswith('.pac')

def is_zip_file(file_path):
    """检查文件是否为ZIP格式"""
    return zipfile.is_zipfile(file_path)

def is_tar_file(file_path):
    """检查文件是否为TAR格式(包括tar.gz, tar.bz2等)"""
    try:
        return tarfile.is_tarfile(file_path)
    except Exception:
        return False
    
def copy_directory(src_dir, dest_dir, overwrite=False):
    """
    复制源目录下的所有文件到目标目录
    
    参数:
        src_dir: 源目录路径
        dest_dir: 目标目录路径
        overwrite: 是否覆盖已存在的文件
    """
    # 确保源目录存在
    if not os.path.exists(src_dir):
        raise FileNotFoundError(f"源目录不存在: {src_dir}")
        return False
    
    # 确保目标目录存在
    os.makedirs(dest_dir, exist_ok=True)
    
    # 遍历源目录中的所有文件和子目录
    for item in os.listdir(src_dir):
        src_path = os.path.join(src_dir, item)
        dest_path = os.path.join(dest_dir, item)
        
        if os.path.isdir(src_path):
            # 如果是子目录，递归复制
            copy_directory(src_path, dest_path, overwrite)
        else:
            # 如果是文件，复制文件
            if os.path.exists(dest_path):
                if overwrite:
                    print(f"覆盖已存在的文件: {dest_path}")
                else:
                    raise FileExistsError(f"目标文件已存在: {dest_path}")
                    return False
            
            print(f"复制文件: {src_path} -> {dest_path}")
            shutil.copy2(src_path, dest_path)  # 保留元数据
    return True

def copy_file(src_file, dest_dir, overwrite=False):
    """
    复制单个文件到目标目录
    
    参数:
        src_file: 源文件路径
        dest_dir: 目标目录路径
        overwrite: 是否覆盖已存在的文件
    """
    # 确保源文件存在
    if not os.path.exists(src_file):
        raise FileNotFoundError(f"源文件不存在: {src_file}")
    
    # 确保目标目录存在
    os.makedirs(dest_dir, exist_ok=True)
    
    # 构建目标文件路径
    dest_file = os.path.join(dest_dir, os.path.basename(src_file))
    
    # 检查目标文件是否已存在
    if os.path.exists(dest_file):
        if overwrite:
            print(f"覆盖已存在的文件: {dest_file}")
        else:
            raise FileExistsError(f"目标文件已存在: {dest_file}")
    
    # 复制文件（使用copy2保留元数据）
    print(f"复制文件: {src_file} -> {dest_file}")
    shutil.copy2(src_file, dest_file)
    
    return dest_file

def extract_file(file_path, extract_dir=None, overwrite=False):
    """
    解压文件到指定目录
    
    参数:
        file_path: 要解压的文件路径
        extract_dir: 解压目标目录，默认为文件所在目录下的同名文件夹
        overwrite: 是否覆盖已存在的文件
    """
    if not os.path.exists(file_path):
        raise FileNotFoundError(f"文件不存在: {file_path}")
    
    # 默认解压目录为文件名（不含扩展名）
    if extract_dir is None:
        file_name = os.path.splitext(os.path.basename(file_path))[0]
        extract_dir = os.path.join(os.path.dirname(file_path), file_name)
    
    # 确保解压目录存在
    os.makedirs(extract_dir, exist_ok=True)
    
    print(f"解压文件: {file_path} -> {extract_dir}")
    
    # 根据文件类型选择解压方法
    if is_zip_file(file_path):
        with zipfile.ZipFile(file_path, 'r') as zip_ref:
            # 检查是否有文件会被覆盖
            if not overwrite:
                for member in zip_ref.namelist():
                    target_path = os.path.join(extract_dir, member)
                    if os.path.exists(target_path):
                        raise FileExistsError(f"解压时会覆盖已存在的文件: {target_path}")
            
            # 解压文件
            zip_ref.extractall(extract_dir)
    elif is_tar_file(file_path):
        with tarfile.open(file_path, 'r:*') as tar_ref:
            # 检查是否有文件会被覆盖
            if not overwrite:
                for member in tar_ref.getmembers():
                    if member.isfile():
                        target_path = os.path.join(extract_dir, member.name)
                        if os.path.exists(target_path):
                            raise FileExistsError(f"解压时会覆盖已存在的文件: {target_path}")
            
            # 解压文件
            tar_ref.extractall(extract_dir)
    else:
        raise ValueError(f"不支持的文件格式: {file_path}")
    
    print(f"文件已成功解压到: {extract_dir}")
    return extract_dir

def download_main(src_file_path):
    # 获取当前时间  
    now = datetime.now()  
    # 打印当前时间  
    print("当前时间:", now)  
    # 如果你想要以特定的格式打印时间，可以使用strftime方法  
    formatted_now = now.strftime("%Y%m%d")  

    parser = argparse.ArgumentParser(description='复制单个文件并解压')
    # src_file_path = r'\\10.10.34.111\Dailybuild'
    # src_file_path += r'\SW610_H01\\'
    
    dest_file_path = r'C:\pac'
    dest_file_name = ''
    coyt_file_flag = True
    
    if is_pac_file(src_file_path) is not True:
        src_file_path += r'\\'
        src_file_path += formatted_now
        
        # 定义可选参数（使用 --src-file 和 --dest-dir）
        parser.add_argument('--src-dir', help='源文件路径', 
                            default=src_file_path)
        parser.add_argument('--dest-dir', help='目标目录路径', 
                            default=dest_file_path)

        parser.add_argument('--extract', action='store_false', default=True, help='是否解压文件')
        parser.add_argument('--overwrite', action='store_false', default=True, help='是否覆盖已存在的文件')
        
        args = parser.parse_args()
        
        # 打印参数值，用于调试
        print(f"参数值 - src_file: {args.src_dir}")
        print(f"参数值 - dest_dir: {args.dest_dir}")
        print(f"参数值 - extract: {args.extract}")
        print(f"参数值 - overwrite: {args.overwrite}")

        try:
            # 复制文件
            # copied_file = copy_file(args.src_file, args.dest_dir, args.overwrite)
            # 复制目录下的所有文件
            coyt_file_flag = copy_directory(args.src_dir, args.dest_dir, args.overwrite)
            
            # 如果需要解压，遍历目标目录并解压所有压缩文件
            if args.extract:
                for root, _, files in os.walk(args.dest_dir):
                    for file in files:
                        file_path = os.path.join(root, file)
                        if is_zip_file(file_path) or is_tar_file(file_path):
                            dest_file_path = os.path.splitext(file_path)[0]
                            dest_file_name = os.path.splitext(file)[0]
                            extract_file(file_path, overwrite=args.overwrite)
                        else:
                            print(f"跳过非压缩文件: {file_path}")
            
            print("操作完成！")
        except Exception as e:
            print(f"发生错误: {e}")

        # dest_file_path += r'\Bins\'
        dest_file_path = os.path.join(dest_file_path, 'Bins\\')
        dest_file_path += dest_file_name
        dest_file_path += '.pac'
    else:
        dest_file_path = src_file_path
        
    if(coyt_file_flag is True):
        download_pac(dest_file_path)
    else:
        print("----------------------------文件复制失败----------------------")
        while True:
            time.sleep(1)
'''
def find_pac_download_status(main_window):
    list_obj = main_window.child_window(auto_id="59648", control_type="List")
    while True:
            time.sleep(0.5)
        # try :
            list_1 = list_obj.child_window(title="1", control_type="ListItem")
            if list_1.exists() is False:
                continue
            
            list_1_RESET = list_1.child_window(title="_RESET_",control_type="Text")
            if list_1_RESET.exists():
                return True
            
            list_2 = list_obj.child_window(title="2", control_type="ListItem")
            if list_2.exists() is False:
                continue
            
            list_2_RESET = list_2.child_window(title="_RESET_",control_type="Text")
            if list_2_RESET.exists():
                return True
        # except Exception as e:
        #     print(e)
        #     print("找不到等待项")
'''
def find_pac_download_status(main_window):
    # 定义要查找的项目字典，键为标题，值为要检查的状态文本
    items_to_check = {
        "1": "_RESET_",
        "2": "_RESET_"
    }
    
    # 获取一次列表对象，避免重复查找
    list_obj = main_window.child_window(auto_id="59648", control_type="List")
    
    # 设置超时时间（秒）
    timeout = 150
    start_time = time.time()
    
    while time.time() - start_time < timeout:
        try:
            # 遍历所有要检查的项目
            for title, status_text in items_to_check.items():
                # 查找列表项
                list_item = list_obj.child_window(title=title, control_type="ListItem")
                
                # 如果列表项存在，检查状态文本
                if list_item.exists():
                    status_control = list_item.child_window(title=status_text, control_type="Text")
                    if status_control.exists():
                        print("完成下载")
                        return True
            
            # 如果所有项目都检查过但没有找到匹配项，等待一段时间再重试
            time.sleep(0.5)  # 避免CPU占用过高
            
        except Exception as e:
            print(f"UI查找错误: {e}")
            time.sleep(1)  # 发生错误时等待更长时间
    
    print("查找超时，未找到匹配的下载状态")
    return False

def download_pac(file_path):
    from pywinauto import Application
    from pywinauto.findwindows import find_window
    from pywinauto import win32functions

    # 启动新应用程序
    app = Application(backend="uia").start("D:\\Program Files\\Download_R27.23.2902\\Bin\\ResearchDownload.exe")

    main_window1 = app.window(title_re=".*ResearchDownload")

    # 等待窗口出现/消失
    main_window1.wait("visible", timeout=10)
    # main_window.wait_not("visible", timeout=10)

    # 窗口最大化/最小化/还原
    # main_window.restore()

    # 检查窗口是否存在
    if main_window1.exists():
        print("窗口存在")
        
    main_window = main_window1
    # time.sleep(2) 
    # 获取包含按钮的窗口
    dialog = main_window.window(title="Download")
    if dialog.exists():
        # 方法1：直接通过按钮文本点击"否"按钮
        dialog.child_window(title="否(N)", control_type="Button").click()
    # main_window.print_control_identifiers()
    # 获取按钮并点击
    # button = main_window.ButtonName  
    button = main_window.child_window(title="Load packet", control_type="Button")
    # button.click()
    button.click_input()  # 模拟鼠标点击
    time.sleep(2)  
    # 关键修改：将文件选择对话框定位为顶级窗口
    # 使用find_window函数直接在所有顶级窗口中查找标题为"打开"的窗口
    file_dialog_hwnd = find_window(title="打开")
    file_dialog = app.window(handle=file_dialog_hwnd)

    # 打印文件选择对话框的控件树，用于调试
    
    # 定位路径输入框并输入路径
    edit = file_dialog.child_window(class_name="Edit")
    edit.set_text(file_path)

    # 触发"打开"按钮
    open_button = file_dialog.child_window(title="打开(O)", control_type="Button")
    open_button.click()

    start_download_button = main_window.child_window(title="Start downloading", control_type="Button")
    start_download_button.click_input()  # 模拟鼠标点击
    stop_download_button = main_window.child_window(title="Stop downloading", control_type="Button")
    # 获取按钮的坐标并直接发送鼠标点击消息
    rect = stop_download_button.rectangle()
    center = (rect.left + rect.width() // 2, rect.top + rect.height() // 2)
    
    print("下载中...")
    time.sleep(1)
    # main_window.print_control_identifiers()
    
    # child_window(auto_id="59648", control_type="List")
    # child_window(title="1", control_type="ListItem")
    find_pac_download_status(main_window)
    
    # stop_download_button.click()
    print("点击")
    # stop_download_button.click_input()  # 模拟鼠标点击
    win32functions.SetCursorPos(*center)  # 使用 * 解包元组为两个参数
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, 0, 0)
    win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, 0, 0)
    print("结束")
    time.sleep(10)
    # 关闭窗口
    main_window.close()

if __name__ == "__main__":
    # download_main(r"\\10.10.34.111\Dailybuild\SW610_H01")
    # main()
    i = 0
    while True:
        time.sleep(1)
        i += 1
        print("回合："+str(i))
        download_main(r'C:\pac\LLAJ199.2.0.1.3T13R0703_M610\Bins\LLAJ199.2.0.1.3T13R0703_M610.pac')
        

